{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch\nimport torchvision\nimport torchvision.transforms as transforms\n\ntransform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\nbatch_size = 8\ntrain_dataset = torchvision.datasets.ImageFolder(\"/kaggle/input/cifar100/CIFAR100/TRAIN\", transform=transform)\n\ntest_dataset = torchvision.datasets.ImageFolder(\"/kaggle/input/cifar100/CIFAR100/TEST\", transform=transform)\n\ntrain_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)\n\ntest_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)","metadata":{"execution":{"iopub.status.busy":"2023-05-22T15:24:07.680879Z","iopub.execute_input":"2023-05-22T15:24:07.681328Z","iopub.status.idle":"2023-05-22T15:24:08.156194Z","shell.execute_reply.started":"2023-05-22T15:24:07.681278Z","shell.execute_reply":"2023-05-22T15:24:08.155261Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\n\n# functions to show an image\n\n\ndef imshow(img):\n    img = img / 2 + 0.5     # unnormalize\n    npimg = img.numpy()\n    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n    plt.show()\n\n\n# get some random training images\ndataiter = iter(train_loader)\n# images, labels = dataiter.next()\nimages, labels = next(dataiter)\n\n# show images\nimshow(torchvision.utils.make_grid(images))\n# print labels\nprint(labels.shape)","metadata":{"execution":{"iopub.status.busy":"2023-05-22T15:24:12.257840Z","iopub.execute_input":"2023-05-22T15:24:12.258188Z","iopub.status.idle":"2023-05-22T15:24:12.572328Z","shell.execute_reply.started":"2023-05-22T15:24:12.258160Z","shell.execute_reply":"2023-05-22T15:24:12.571136Z"},"trusted":true},"execution_count":5,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"name":"stdout","text":"torch.Size([8])\n","output_type":"stream"}]},{"cell_type":"code","source":"import math\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.nn import init\n\nfrom functools import partial\n\nfrom timm.models.layers import DropPath, to_2tuple, trunc_normal_\nfrom timm.models.registry import register_model\nfrom timm.models.vision_transformer import _cfg\nimport math\n\ndef conv3x3(in_planes, out_planes, stride=1):\n    \"3x3 convolution with padding\"\n    return nn.Conv2d(\n        in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False\n    )\n\n\nclass BasicBlock(nn.Module):\n    expansion = 1\n\n    def __init__(\n        self, inplanes, planes, stride=1, downsample=None, use_triplet_attention=False\n    ):\n        super(BasicBlock, self).__init__()\n        self.conv1 = conv3x3(inplanes, planes, stride)\n        self.bn1 = nn.BatchNorm2d(planes)\n        self.relu = nn.ReLU(inplace=True)\n        self.conv2 = conv3x3(planes, planes)\n        self.bn2 = nn.BatchNorm2d(planes)\n        self.downsample = downsample\n        self.stride = stride\n\n        if use_triplet_attention:\n            self.triplet_attention = TripletAttention(planes, 16)\n        else:\n            self.triplet_attention = None\n\n    def forward(self, x):\n        residual = x\n\n        out = self.conv1(x)\n        out = self.bn1(out)\n        out = self.relu(out)\n\n        out = self.conv2(out)\n        out = self.bn2(out)\n\n        if self.downsample is not None:\n            residual = self.downsample(x)\n\n        if not self.triplet_attention is None:\n            out = self.triplet_attention(out)\n\n        out += residual\n        out = self.relu(out)\n\n        return out\n\n\nclass Bottleneck(nn.Module):\n    expansion = 4\n\n    def __init__(\n        self, inplanes, planes, stride=1, downsample=None, use_triplet_attention=False\n    ):\n        super(Bottleneck, self).__init__()\n        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)\n        self.bn1 = nn.BatchNorm2d(planes)\n        self.conv2 = nn.Conv2d(\n            planes, planes, kernel_size=3, stride=stride, padding=1, bias=False\n        )\n        self.bn2 = nn.BatchNorm2d(planes)\n        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)\n        self.bn3 = nn.BatchNorm2d(planes * 4)\n        self.relu = nn.ReLU(inplace=True)\n        self.downsample = downsample\n        self.stride = stride\n\n        if use_triplet_attention:\n            self.triplet_attention = TripletAttention(planes * 4, 16)\n        else:\n            self.triplet_attention = None\n\n    def forward(self, x):\n        residual = x\n\n        out = self.conv1(x)\n        out = self.bn1(out)\n        out = self.relu(out)\n\n        out = self.conv2(out)\n        out = self.bn2(out)\n        out = self.relu(out)\n\n        out = self.conv3(out)\n        out = self.bn3(out)\n\n        if self.downsample is not None:\n            residual = self.downsample(x)\n\n        if not self.triplet_attention is None:\n            out = self.triplet_attention(out)\n\n        out += residual\n        out = self.relu(out)\n\n        return out\n\n\nclass ResNet(nn.Module):\n    def __init__(self, block, layers, network_type, num_classes, att_type=None):\n        self.inplanes = 64\n        super(ResNet, self).__init__()\n        self.network_type = network_type\n        # different model config between ImageNet and CIFAR\n        if network_type == \"ImageNet\":\n            self.conv1 = nn.Conv2d(\n                3, 64, kernel_size=7, stride=2, padding=3, bias=False\n            )\n            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n            self.avgpool = nn.AvgPool2d(7)\n        else:\n            self.conv1 = nn.Conv2d(\n                3, 64, kernel_size=3, stride=1, padding=1, bias=False\n            )\n\n        self.bn1 = nn.BatchNorm2d(64)\n        self.relu = nn.ReLU(inplace=True)\n\n        self.layer1 = self._make_layer(block, 64, layers[0], att_type=att_type)\n        self.layer2 = self._make_layer(\n            block, 128, layers[1], stride=2, att_type=att_type\n        )\n        self.layer3 = self._make_layer(\n            block, 256, layers[2], stride=2, att_type=att_type\n        )\n        self.layer4 = self._make_layer(\n            block, 512, layers[3], stride=2, att_type=att_type\n        )\n\n        self.fc = nn.Linear(512 * block.expansion, num_classes)\n\n        init.kaiming_normal_(self.fc.weight)\n        for key in self.state_dict():\n            if key.split(\".\")[-1] == \"weight\":\n                if \"conv\" in key:\n                    init.kaiming_normal_(self.state_dict()[key], mode=\"fan_out\")\n                if \"bn\" in key:\n                    if \"SpatialGate\" in key:\n                        self.state_dict()[key][...] = 0\n                    else:\n                        self.state_dict()[key][...] = 1\n            elif key.split(\".\")[-1] == \"bias\":\n                self.state_dict()[key][...] = 0\n\n    def _make_layer(self, block, planes, blocks, stride=1, att_type=None):\n        downsample = None\n        if stride != 1 or self.inplanes != planes * block.expansion:\n            downsample = nn.Sequential(\n                nn.Conv2d(\n                    self.inplanes,\n                    planes * block.expansion,\n                    kernel_size=1,\n                    stride=stride,\n                    bias=False,\n                ),\n                nn.BatchNorm2d(planes * block.expansion),\n            )\n\n        layers = []\n        layers.append(\n            block(\n                self.inplanes,\n                planes,\n                stride,\n                downsample,\n                #use_triplet_attention=att_type == \"TripletAttention\",\n            )\n        )\n        self.inplanes = planes * block.expansion\n        for i in range(1, blocks):\n            layers.append(\n                block(\n                    self.inplanes,\n                    planes,\n                    #use_triplet_attention=att_type == \"TripletAttention\",\n                )\n            )\n\n        return nn.Sequential(*layers)\n\n    def forward(self, x):\n        x = self.conv1(x)\n        x = self.bn1(x)\n        x = self.relu(x)\n        if self.network_type == \"ImageNet\":\n            x = self.maxpool(x)\n\n        x = self.layer1(x)\n        x = self.layer2(x)\n        x = self.layer3(x)\n        x = self.layer4(x)\n\n        if self.network_type == \"ImageNet\":\n            x = self.avgpool(x)\n        else:\n            x = F.avg_pool2d(x, 4)\n        x = x.view(x.size(0), -1)\n        x = self.fc(x)\n        return x\n\nclass Mlp(nn.Module):\n    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):\n        super().__init__()\n        out_features = out_features or in_features\n        hidden_features = hidden_features or in_features\n        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)\n        self.dwconv = DWConv(hidden_features)\n        self.act = act_layer()\n        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)\n        self.drop = nn.Dropout(drop)\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def forward(self, x):\n        x = self.fc1(x)\n        x = self.dwconv(x)\n        x = self.act(x)\n        x = self.drop(x)\n        x = self.fc2(x)\n        x = self.drop(x)\n        return x\n\n\n\n\nclass LKA(nn.Module):\n    def __init__(self, dim):\n        super().__init__()\n        self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)\n        self.conv_spatial = nn.Conv2d(dim, dim, 7, stride=1, padding=9, groups=dim, dilation=3)\n        self.conv1 = nn.Conv2d(dim, dim, 1)\n\n\n    def forward(self, x):\n        u = x.clone()        \n        attn = self.conv0(x)\n        attn = self.conv_spatial(attn)\n        attn = self.conv1(attn)\n\n        return u * attn\n\n\nclass Attention(nn.Module):\n    def __init__(self, d_model):\n        super().__init__()\n\n        self.proj_1 = nn.Conv2d(d_model, d_model, 1)\n        self.activation = nn.GELU()\n        self.spatial_gating_unit = LKA(d_model)\n        self.proj_2 = nn.Conv2d(d_model, d_model, 1)\n\n    def forward(self, x):\n        shorcut = x.clone()\n        x = self.proj_1(x)\n        x = self.activation(x)\n        x = self.spatial_gating_unit(x)\n        x = self.proj_2(x)\n        x = x + shorcut\n        return x\n\n\nclass vanBlock(nn.Module):\n    expansion = 1\n    def __init__(self, dim, mlp_ratio=4., drop=0.,drop_path=0., act_layer=nn.GELU):\n        super().__init__()\n        self.norm1 = nn.BatchNorm2d(dim)\n        self.attn = Attention(dim)\n        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n\n        self.norm2 = nn.BatchNorm2d(dim)\n        mlp_hidden_dim = int(dim * mlp_ratio)\n        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n        layer_scale_init_value = 1e-2            \n        self.layer_scale_1 = nn.Parameter(\n            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n        self.layer_scale_2 = nn.Parameter(\n            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def forward(self, x):\n        x = x + self.drop_path(self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) * self.attn(self.norm1(x)))\n        x = x + self.drop_path(self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) * self.mlp(self.norm2(x)))\n        return x\n\n\ndef ResidualNet(network_type, depth, num_classes, att_type):\n\n    assert network_type in [\n        \"ImageNet\",\n        \"CIFAR10\",\n        \"CIFAR100\",\n    ], \"network type should be ImageNet or CIFAR10 / CIFAR100\"\n    assert depth in [18, 34, 50, 101], \"network depth should be 18, 34, 50 or 101\"\n\n    if depth == 18:\n        model = ResNet(BasicBlock, [2, 2, 2, 2], network_type, num_classes, att_type)\n\n    elif depth == 34:\n        model = ResNet(BasicBlock, [3, 4, 6, 3], network_type, num_classes, att_type)\n\n    elif depth == 50:\n        model = ResNet(Bottleneck, [3, 4, 6, 3], network_type, num_classes, att_type)\n\n    elif depth == 101:\n        model = ResNet(Bottleneck, [3, 4, 23, 3], network_type, num_classes, att_type)\n\n    return model\n\ndef vanNet(network_type, depth, num_classes, att_type):\n\n    assert network_type in [\n        \"ImageNet\",\n        \"CIFAR10\",\n        \"CIFAR100\",\n    ], \"network type should be ImageNet or CIFAR10 / CIFAR100\"\n    assert depth in [18, 34, 50, 101], \"network depth should be 18, 34, 50 or 101\"\n\n    if depth == 18:\n        model = ResNet(vanBlock, [2, 2, 2, 2], network_type, num_classes, att_type)\n\n    elif depth == 34:\n        model = ResNet(vanBlock, [3, 4, 6, 3], network_type, num_classes, att_type)\n\n    elif depth == 50:\n        model = ResNet(vanBlock, [3, 4, 6, 3], network_type, num_classes, att_type)\n\n    elif depth == 101:\n        model = ResNet(vanBlock, [3, 4, 23, 3], network_type, num_classes, att_type)\n\n    return model","metadata":{"execution":{"iopub.status.busy":"2023-05-22T15:35:42.048770Z","iopub.execute_input":"2023-05-22T15:35:42.049156Z","iopub.status.idle":"2023-05-22T15:35:42.993430Z","shell.execute_reply.started":"2023-05-22T15:35:42.049112Z","shell.execute_reply":"2023-05-22T15:35:42.992484Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"#device=\"cuda\"\ndevice=\"cpu\"\nnet=vanNet(\"CIFAR100\",50,100,None).to(device)\nprint(net)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch.optim as optim\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(net.parameters(), lr=0.0005)\nprint(len(train_loader))","metadata":{"execution":{"iopub.status.busy":"2023-05-21T07:52:07.295454Z","iopub.execute_input":"2023-05-21T07:52:07.296492Z","iopub.status.idle":"2023-05-21T07:52:07.303476Z","shell.execute_reply.started":"2023-05-21T07:52:07.296454Z","shell.execute_reply":"2023-05-21T07:52:07.302358Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from tqdm import tqdm\ndef train(epoch):\n    net.train()\n    # Loop over each batch from the training set\n    train_tqdm = tqdm(train_loader, desc=\"Epoch \" + str(epoch))\n    for batch_idx, (data, target) in enumerate(train_tqdm):\n        # Copy data to GPU if needed\n        data = data.to(device)\n        target = target.to(device)\n        # Zero gradient buffers\n        optimizer.zero_grad()\n        # Pass data through the network\n        output = net(data)\n        # Calculate loss\n        loss = criterion(output, target)\n        # Backpropagate\n        loss.backward()\n        # Update weights\n        optimizer.step()  # w - alpha * dL / dw\n        train_tqdm.set_postfix({\"loss\": \"%.3g\" % loss.item()})\n\ndef validate(lossv,top1AccuracyList,top5AccuracyList):\n    net.eval()\n    val_loss = 0\n    top1Correct = 0\n    top5Correct = 0\n    for index,(data, target) in enumerate(test_loader):\n        data = data.to(device)\n        labels = target.to(device)\n        outputs = net(data)\n        val_loss += criterion(outputs, labels).data.item()\n        _, top1Predicted = torch.max(outputs.data, 1)\n        top5Predicted = torch.topk(outputs.data, k=5, dim=1, largest=True)[1]\n        top1Correct += (top1Predicted == labels).cpu().sum().item()\n        label_resize = labels.view(-1, 1).expand_as(top5Predicted)\n        top5Correct += torch.eq(top5Predicted, label_resize).view(-1).cpu().sum().float().item()\n\n    val_loss /= len(test_loader)\n    lossv.append(val_loss)\n\n    top1Acc=100*top1Correct / len(test_loader.dataset)\n    top5Acc=100*top5Correct / len(test_loader.dataset)\n    top1AccuracyList.append(top1Acc)\n    top5AccuracyList.append(top5Acc)\n    \n    print('\\nValidation set: Average loss: {:.4f}, Top1Accuracy: {}/{} ({:.0f}%) Top5Accuracy: {}/{} ({:.0f}%)\\n'.format(\n        val_loss, top1Correct, len(test_loader.dataset), top1Acc,top5Correct, len(test_loader.dataset), top5Acc))\n#     accuracy = 100. * correct.to(torch.float32) / len(testloader.dataset)\n#     accv.append(accuracy)","metadata":{"execution":{"iopub.status.busy":"2023-05-21T07:52:12.427197Z","iopub.execute_input":"2023-05-21T07:52:12.427558Z","iopub.status.idle":"2023-05-21T07:52:12.442993Z","shell.execute_reply.started":"2023-05-21T07:52:12.427529Z","shell.execute_reply":"2023-05-21T07:52:12.441999Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import time\n\nvan_netLossv = []\nvan_netTop1AccuracyList = []   # top1准确率列表\nvan_netTop5AccuracyList = []   # top5准确率列表\nmax_epoch = 5\ntraining_time = 0.0\nfor epoch in range(max_epoch):  # loop over the dataset multiple times\n    start = time.time()\n    van_net = train(van_net, epoch)\n    end = time.time()\n    training_time += end-start\n    with torch.no_grad():\n        validate(van_net, van_netLossv,van_netTop1AccuracyList,van_netTop5AccuracyList)\n\n\n        \nprint('Finished Training')\nprint('Training complete in {:.0f}m {:.0f}s'.format(training_time // 60, training_time % 60))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# 绘制曲线\nplt.figure(figsize=(5,3))\nplt.plot(np.arange(1,len(lossv)), lossv)\nplt.title('validation loss')\n\nplt.figure(figsize=(5,3))\nplt.plot(np.arange(1,len(top1AccuracyList)), top1AccuracyList)\nplt.title('validation top1 accuracy')\n\nplt.figure(figsize=(5,3))\nplt.plot(np.arange(1,len(top5AccuracyList)), top5AccuracyList)\nplt.title('validation top5 accuracy')","metadata":{"execution":{"iopub.status.busy":"2023-05-21T07:52:28.254928Z","iopub.execute_input":"2023-05-21T07:52:28.255323Z","iopub.status.idle":"2023-05-21T07:52:28.297739Z","shell.execute_reply.started":"2023-05-21T07:52:28.255292Z","shell.execute_reply":"2023-05-21T07:52:28.296549Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom functools import partial\n\nfrom timm.models.layers import DropPath, to_2tuple, trunc_normal_\nfrom timm.models.registry import register_model\nfrom timm.models.vision_transformer import _cfg\nimport math\n\nclass Mlp(nn.Module):\n    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):\n        super().__init__()\n        out_features = out_features or in_features\n        hidden_features = hidden_features or in_features\n        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)\n        self.dwconv = DWConv(hidden_features)\n        self.act = act_layer()\n        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)\n        self.drop = nn.Dropout(drop)\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def forward(self, x):\n        x = self.fc1(x)\n        x = self.dwconv(x)\n        x = self.act(x)\n        x = self.drop(x)\n        x = self.fc2(x)\n        x = self.drop(x)\n        return x\n\n\n\n\nclass LKA(nn.Module):\n    def __init__(self, dim):\n        super().__init__()\n        self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)\n        self.conv_spatial = nn.Conv2d(dim, dim, 7, stride=1, padding=9, groups=dim, dilation=3)\n        self.conv1 = nn.Conv2d(dim, dim, 1)\n\n\n    def forward(self, x):\n        u = x.clone()        \n        attn = self.conv0(x)\n        attn = self.conv_spatial(attn)\n        attn = self.conv1(attn)\n\n        return u * attn\n\n\nclass Attention(nn.Module):\n    def __init__(self, d_model):\n        super().__init__()\n\n        self.proj_1 = nn.Conv2d(d_model, d_model, 1)\n        self.activation = nn.GELU()\n        self.spatial_gating_unit = LKA(d_model)\n        self.proj_2 = nn.Conv2d(d_model, d_model, 1)\n\n    def forward(self, x):\n        shorcut = x.clone()\n        x = self.proj_1(x)\n        x = self.activation(x)\n        x = self.spatial_gating_unit(x)\n        x = self.proj_2(x)\n        x = x + shorcut\n        return x\n\n\nclass Block(nn.Module):\n    def __init__(self, dim, mlp_ratio=4., drop=0.,drop_path=0., act_layer=nn.GELU):\n        super().__init__()\n        self.norm1 = nn.BatchNorm2d(dim)\n        self.attn = Attention(dim)\n        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n\n        self.norm2 = nn.BatchNorm2d(dim)\n        mlp_hidden_dim = int(dim * mlp_ratio)\n        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n        layer_scale_init_value = 1e-2            \n        self.layer_scale_1 = nn.Parameter(\n            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n        self.layer_scale_2 = nn.Parameter(\n            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def forward(self, x):\n        x = x + self.drop_path(self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) * self.attn(self.norm1(x)))\n        x = x + self.drop_path(self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) * self.mlp(self.norm2(x)))\n        return x\n\n\nclass OverlapPatchEmbed(nn.Module):\n    \"\"\" Image to Patch Embedding\n    \"\"\"\n\n    def __init__(self, img_size=224, patch_size=7, stride=4, in_chans=3, embed_dim=768):\n        super().__init__()\n        patch_size = to_2tuple(patch_size)\n        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride,\n                              padding=(patch_size[0] // 2, patch_size[1] // 2))\n        self.norm = nn.BatchNorm2d(embed_dim)\n\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def forward(self, x):\n        x = self.proj(x)\n        _, _, H, W = x.shape\n        x = self.norm(x)        \n        return x, H, W\n\n\nclass VAN(nn.Module):\n    def __init__(self, img_size=224, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512],\n                mlp_ratios=[4, 4, 4, 4], drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,\n                 depths=[3, 4, 6, 3], num_stages=4, flag=False):\n        super().__init__()\n        if flag == False:\n            self.num_classes = num_classes\n        self.depths = depths\n        self.num_stages = num_stages\n\n        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule\n        cur = 0\n\n        for i in range(num_stages):\n            patch_embed = OverlapPatchEmbed(img_size=img_size if i == 0 else img_size // (2 ** (i + 1)),\n                                            patch_size=7 if i == 0 else 3,\n                                            stride=4 if i == 0 else 2,\n                                            in_chans=in_chans if i == 0 else embed_dims[i - 1],\n                                            embed_dim=embed_dims[i])\n\n            block = nn.ModuleList([Block(\n                dim=embed_dims[i], mlp_ratio=mlp_ratios[i], drop=drop_rate, drop_path=dpr[cur + j])\n                for j in range(depths[i])])\n            norm = norm_layer(embed_dims[i])\n            cur += depths[i]\n\n            setattr(self, f\"patch_embed{i + 1}\", patch_embed)\n            setattr(self, f\"block{i + 1}\", block)\n            setattr(self, f\"norm{i + 1}\", norm)\n\n        # classification head\n        self.head = nn.Linear(embed_dims[3], num_classes) if num_classes > 0 else nn.Identity()\n\n        self.apply(self._init_weights)\n\n    def _init_weights(self, m):\n        if isinstance(m, nn.Linear):\n            trunc_normal_(m.weight, std=.02)\n            if isinstance(m, nn.Linear) and m.bias is not None:\n                nn.init.constant_(m.bias, 0)\n        elif isinstance(m, nn.LayerNorm):\n            nn.init.constant_(m.bias, 0)\n            nn.init.constant_(m.weight, 1.0)\n        elif isinstance(m, nn.Conv2d):\n            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            fan_out //= m.groups\n            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n            if m.bias is not None:\n                m.bias.data.zero_()\n\n    def freeze_patch_emb(self):\n        self.patch_embed1.requires_grad = False\n\n    @torch.jit.ignore\n    def no_weight_decay(self):\n        return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'}  # has pos_embed may be better\n\n    def get_classifier(self):\n        return self.head\n\n    def reset_classifier(self, num_classes, global_pool=''):\n        self.num_classes = num_classes\n        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()\n\n    def forward_features(self, x):\n        B = x.shape[0]\n\n        for i in range(self.num_stages):\n            patch_embed = getattr(self, f\"patch_embed{i + 1}\")\n            block = getattr(self, f\"block{i + 1}\")\n            norm = getattr(self, f\"norm{i + 1}\")\n            x, H, W = patch_embed(x)\n            for blk in block:\n                x = blk(x)\n            x = x.flatten(2).transpose(1, 2)\n            x = norm(x)\n            if i != self.num_stages - 1:\n                x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()\n\n        return x.mean(dim=1)\n\n    def forward(self, x):\n        x = self.forward_features(x)\n        x = self.head(x)\n\n        return x\n\n\nclass DWConv(nn.Module):\n    def __init__(self, dim=768):\n        super(DWConv, self).__init__()\n        self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim)\n\n    def forward(self, x):\n        x = self.dwconv(x)\n        return x\n\n\ndef _conv_filter(state_dict, patch_size=16):\n    \"\"\" convert patch embedding weight from manual patchify + linear proj to conv\"\"\"\n    out_dict = {}\n    for k, v in state_dict.items():\n        if 'patch_embed.proj.weight' in k:\n            v = v.reshape((v.shape[0], 3, patch_size, patch_size))\n        out_dict[k] = v\n\n    return out_dict\n\n\nmodel_urls = {\n    \"van_b0\": \"https://huggingface.co/Visual-Attention-Network/VAN-Tiny-original/resolve/main/van_tiny_754.pth.tar\",\n    \"van_b1\": \"https://huggingface.co/Visual-Attention-Network/VAN-Small-original/resolve/main/van_small_811.pth.tar\",\n    \"van_b2\": \"https://huggingface.co/Visual-Attention-Network/VAN-Base-original/resolve/main/van_base_828.pth.tar\",\n    \"van_b3\": \"https://huggingface.co/Visual-Attention-Network/VAN-Large-original/resolve/main/van_large_839.pth.tar\",\n}\n\n\ndef load_model_weights(model, arch, kwargs):\n    url = model_urls[arch]\n    checkpoint = torch.hub.load_state_dict_from_url(\n        url=url, map_location=\"cpu\", check_hash=True\n    )\n    strict = True\n    if \"num_classes\" in kwargs and kwargs[\"num_classes\"] != 1000:\n        strict = False\n        del checkpoint[\"state_dict\"][\"head.weight\"]\n        del checkpoint[\"state_dict\"][\"head.bias\"]\n    model.load_state_dict(checkpoint[\"state_dict\"], strict=strict)\n    return model\n\n\n@register_model\ndef van_b0(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[32, 64, 160, 256], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 5, 2],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b0\", kwargs)\n    return model\n\n\n@register_model\ndef van_b1(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 4, 2],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b1\", kwargs)\n    return model\n\n@register_model\ndef van_b2(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 12, 3],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b2\", kwargs)\n    return model\n\n@register_model\ndef van_b3(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 5, 27, 3],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b3\", kwargs)\n    return model\n\n@register_model\ndef van_b4(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 6, 40, 3],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b4\", kwargs)\n    return model\n\n\n@register_model\ndef van_b5(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[96, 192, 480, 768], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 24, 3],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b5\", kwargs)\n    return model\n\n\n@register_model\ndef van_b6(pretrained=False, **kwargs):\n    model = VAN(\n        embed_dims=[96, 192, 384, 768], mlp_ratios=[8, 8, 4, 4],\n        norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[6,6,90,6],\n        **kwargs)\n    model.default_cfg = _cfg()\n    if pretrained:\n        model = load_model_weights(model, \"van_b6\", kwargs)\n    return model","metadata":{},"execution_count":null,"outputs":[]}]}